שיעור מספר 3: "מחלקות וטיפוסים"

Transcription

1 שיעור מספר 3: "מחלקות וטיפוסים" בית הספר למדעי המחשב

2 על סדר היום מודל הזיכרון של Java Heap and Stack העברת ארגומנטים מנגנוני שפת Java עצמים ושירותי מופע 2

3 העברת ארגומנטים כאשר מתבצעת קריאה לשרות, ערכי הארגומנטים נקשרים לפרמטרים הפורמליים של השרות לפי הסדר, ומתבצעת השמה לפני ביצוע גוף השרות. בהעברת ערך לשרות הערך מועתק לפרמטר הפורמלי צורה זאת של העברת פרמטרים נקראת call by value כאשר הארגומנט המועבר הוא הפנייה )התייחסות, )reference העברת הפרמטר מעתיקה את ההתייחסות. בשפות תכנות אחרות ניתן לבצע העברה של המצביע עצמו גם reference מועבר by value ב Java 3

4 ע) העברת פרמטרים by value העברת פרמטרים by value "י העתקה( יוצרת מספר מקרים מבלבלים, שידרשו מאיתנו הכרות מעמיקה יותר עם מודל הזיכרון של Java למשל, מה מדפיס הקוד הבא? public class CallByValue { public static void settofive(int arg){ arg = 5; public static void main(string[] args) { int x = 0; System.out.println("Before: x=" + x); settofive(x); System.out.println("After: x=" + x); 4

5 מודל הזיכרון של Java STACK HEAP משתנים גלובלים ועצמים אינו תלוי במתודה הנוכחית שרצה משתנים מקומיים וארגומנטים כל מתודה משתמשת באזור מסוים של המחסנית CODE קוד התוכנית 5

6 Primitives by value println משתנים מקומיים וארגומנטים כל מתודה משתמשת באזור מסוים של main המחסנית x 0 args STACK HEAP משתנים גלובלים ועצמים אינו תלוי במתודה הנוכחית שרצה [ ] Before: x=0 public class CallByValue { public static void settofive(int arg){ arg = 5; CODE public static void main(string[] args) { int x = 0; System.out.println("Before: x=" + x); settofive(x); System.out.println("After: x=" + x); 6

7 Primitives by value settofive STACK HEAP arg 50 main args x 0 [ ] Before: x=0 public class CallByValue { public static void settofive(int arg){ arg = 5; CODE public static void main(string[] args) { int x = 0; System.out.println("Before: x=" + x); settofive(x); System.out.println("After: x=" + x); ש settofive println מסיימת לאחר את אתריצתה המקום שהוקצה משוחרר עלעלה- ה- Stack עבורה 7

8 Primitives by value println STACK HEAP After: x=0 main args x 0 [ ] Before: x=0 public class CallByValue { public static void settofive(int arg){ arg = 5; CODE public static void main(string[] args) { int x = 0; System.out.println("Before: x=" + x); settofive(x); System.out.println("After: x=" + x); ש println main מסיימת את מסיימת לאחר את ריצתה ריצתה המקום המקום שהוקצה שהוקצה משוחרר Stack על ה- עבורה 8

9 שמות מקומיים בדוגמא ראינו כי הפרמטר הפורמלי arg הארגומנט x קיבל את הערך של בחירת השמות השונים אינה משמעותית - יכולנו לקרוא לשני המשתנים באותו שם ולקבל התנהגות זהה שם של משתנה מקומי מסתיר משתנים בשם זהה הנמצאים בתחום עוטף או גלובלים נראה את ההתנהגות הזו בהמשך השיעור, בדוגמא של בנאים. מתודה מכירה רק משתני מחסנית הנמצאים באזור שהוקצה לה על המחסנית )frame( 9

10 מה יקרה אם המשתנה המקומי x שהועבר היה מטיפוס הפנייה? למשל, מה מדפיס הקוד הבא? import java.util.arrays; //explained later... public class CallByValue { public static void settozero(int [] arr){ arr = new int[3]; public static void main(string[] args) { int [] arr = {4,5; System.out.println("Before: arr=" + Arrays.toString(arr)); settozero(arr); System.out.println("After: arr=" + Arrays.toString(arr)); 10

11 Arrays.toString Reference by value STACK HEAP 4 [4,5] main arr args 5 [ ] public class CallByValue { CODE public static void settozero(int [] arr){ arr = new int[3]; public static void main(string[] args) { int [] arr = {4,5; System.out.println("Before: arr=" + Arrays.toString(arr)); settozero(arr); System.out.println("After: arr=" + Arrays.toString(arr)); 11

12 println Reference by value STACK HEAP 4 [4,5] main arr args 5 [ ] Before: arr= Before: arr= [4,5] public class CallByValue { CODE public static void settozero(int [] arr){ arr = new int[3]; public static void main(string[] args) { int [] arr = {4,5; System.out.println("Before: arr=" + Arrays.toString(arr)); settozero(arr); System.out.println("After: arr=" + Arrays.toString(arr)); 12

13 settozero main arr arr args Reference by value STACK HEAP [ ] 0 [4,5] Before: arr= Before: arr= [4,5] public class CallByValue { CODE public static void settozero(int [] arr){ arr = new int[3]; public static void main(string[] args) { int [] arr = {4,5; System.out.println("Before: arr=" + Arrays.toString(arr)); settozero(arr); System.out.println("After: arr=" + Arrays.toString(arr)); 13

14 Reference by value STACK HEAP Arrays.toString [4,5] 4 [4,5] main arr args 5 [ ] Before: arr= Before: arr= [4,5] public class CallByValue { CODE public static void settozero(int [] arr){ arr = new int[3]; public static void main(string[] args) { int [] arr = {4,5; System.out.println("Before: arr=" + Arrays.toString(arr)); settozero(arr); System.out.println("After: arr=" + Arrays.toString(arr)); 14

15 println main arr args Reference by value STACK HEAP 4 5 [ ] After: arr= [4,5] [4,5] Before: arr= After: arr= [4,5] Before: arr= [4,5] public class CallByValue { CODE public static void settozero(int [] arr){ arr = new int[3]; public static void main(string[] args) { int [] arr = {4,5; System.out.println("Before: arr=" + Arrays.toString(arr)); settozero(arr); System.out.println("After: arr=" + Arrays.toString(arr)); 15

16 הפונקציה הנקראת והעולם שבחוץ בשיטת העברה by value לא יעזור למתודה לשנות את הארגומנט שקיבלה, מכיוון שהיא מקבלת עותק אז איך יכולה מתודה להשפיע על ערכים במתודה שקראה לה? ע"י ערך מוחזר ע"י גישה למשתנים או עצמים שהוקצו ב- Heap מתודות שמשנות את תמונת הזיכרון נקראות בהקשרים מסוימים Mutators או Transformers 16

17 מה מדפיסה התוכנית הבאה? public class CallByValue { static int global = 4; public static int increment(int [] arr){ int local = 5; arr[0]++; global++; return local; public static void main(string[] args) { int [] arr = {4; System.out.println("Before:\narr[0]=" + arr[0] + "\nglobal=" + global); int result = increment(arr); System.out.println("After:\narr[0]=" + arr[0] + "\nglobal=" + global); System.out.println("result = " + result); 17

18 println STACK HEAP 4 main arr args CallByValue.global 4 [ ] Before: arr[0]=4 global=4 public class CallByValue { static int global = 4; CODE public static int increment(int [] arr){ int local = 5; arr[0]++; global++; return local; public static void main(string[] args) { int [] arr = {4; System.out.println("Before:\narr[0]=" + arr[0] + "\nglobal=" + global); int result = increment(arr); System.out.println("After:\narr[0]=" + arr[0] + "\nglobal=" + global); System.out.println("result = " + result); 18

19 increment local 5 STACK HEAP main arr result arr args CallByValue.global 45 [ ] After: arr[0]=5 global=5 Before: arr[0]=4 global=4 public class CallByValue { static int global = 4; CODE public static int increment(int [] arr){ int local = 5; arr[0]++; global++; return local; public static void main(string[] args) { int [] arr = {4; System.out.println("Before:\narr[0]=" + arr[0] + "\nglobal=" + global); int result = increment(arr); System.out.println("After:\narr[0]=" + arr[0] + "\nglobal=" + global); System.out.println("result = " + result); 19

20 println STACK HEAP result = 5 main result arr args 5 5 CallByValue.global 5 [ ] After: arr[0]=5 global=5 Before: arr[0]=4 global=4 public class CallByValue { static int global = 4; CODE public static int increment(int [] arr){ int local = 5; arr[0]++; global++; return local; public static void main(string[] args) { int [] arr = {4; System.out.println("Before:\narr[0]=" + arr[0] + "\nglobal=" + global); int result = increment(arr); System.out.println("After:\narr[0]=" + arr[0] + "\nglobal=" + global); System.out.println("result = " + result); 20

21 println Heap, Heap Hooray! 5 STACK HEAP result = 5 main result arr args 5 5 CallByValue.global 5 [ ] After: arr[0]=5 global=5 Before: arr[0]=4 global=4 public class CallByValue { static int global = 4; CODE public static int increment(int [] arr){ int local = 5; arr[0]++; global++; return local; public static void main(string[] args) { int [] arr = {4; System.out.println("Before: arr[0]=" + arr[0] + "\tglobal=" + global); int result = increment(arr); System.out.println("After: arr[0]=" + arr[0] + "\tglobal=" + global); System.out.println("result = " + result); 21

22 משתני פלט Parameters( )Output איך נכתוב פונקציה שצריכה להחזיר יותר מערך אחד? הפונקציה תחזיר מערך ומה אם הפונקציה צריכה להחזיר נתונים מטיפוסים שונים? הפונקציה תקבל כארגומנטים הפניות לעצמים שהוקצו ע"י הקורא לפונקציה )למשל הפניות למערכים(, ותמלא אותם בערכים משמעותיים ומה קורה אם נרצה שהפונקציה לא תחזיר ערך במקרים מסויימים? החל מ Java 8 המחלקה Optional עוזרת לדמות את ההתנהגות הרצויה, נראה אותה בהמשך הקורס. 22

23 גושי אתחול סטטיים ראינו כי אתחול המשתנה הסטטי התרחש מיד לאחר טעינת המחלקה לזיכרון, עוד לפני פונקצית ה main ניתן לבצע פעולות נוספות )בדרך כלל אתחולים למניהם( מיד לאחר טעינת המחלקה לזיכרון, פעולות אלו יש לציין בתוך בלוק static פרטים נוספים: OO/initial.html 23

24 תמונת הזיכרון האמיתית מודל הזיכרון שתואר כאן הוא פשטני פרטים נוספים נשמרים על המחסנית וב- Heap רבים תמונת הזיכרון האמיתית והמדויקת היא תלוית סביבה ועשויה להשתנות בריצות בסביבות השונות נושא זה נידון בהרחבה בקורס "קומפילציה" 24

25 המחלקה כספריה של שרותים תוכנה 1 בשפת 25 Java

26 המחלקה כספריה של שרותים ניתן לראות במחלקה ספריה של שרותים, מודול: פונקציות עם מכנה משותף אוסף של רוב המחלקות ב,Java נוסף על היותן ספריה, משמשות גם כטיפוס נתונים. ככאלו הן מכילות רכיבים נוספים פרט לשרותי מחלקה. נדון במחלקות אלו בהמשך השיעור ואולם קיימות ב- Java גם כמה מחלקות המשמשות כספריות בלבד. בין השימושיות שבהן: java.lang.math java.util.arrays java.lang.system 26

27 חבילות ומרחב השמות מרחב השמות של Java הוא היררכי בדומה לשמות תיקיות במערכת הקבצים חבילה )package( רקורסיבית יכולה להכיל מחלקות או תת-חבילות בצורה שמה המלא של מחלקה name( )fully qualified כולל את שמות כל החבילות שהיא נמצאת בהן מהחיצונית ביותר עד לפנימית. שמות החבילות מופרדים בנקודות מקובל כי תוכנה הנכתבת בארגון מסוים משתמש בשם התחום האינטרנטי של אותו ארגון כשם החבילות העוטפות 27

28 חבילות ומרחב השמות קיימת התאמה בין מבנה התיקיות ( directories, )folders בפרויקט תוכנה ובין חבילות הקוד )packages( 28

29 חבילות ומרחב השמות כיצד נריץ תוכנית אשר נמצאת ב package כלשהו? ב eclipse ב command line 29

30 משפט import שימוש בשמה המלא של מחלקה מסרבל את הקוד: System.out.println("Before: x=" + java.util.arrays.tostring(arr)); ניתן לחסוך שימוש בשם מלא ע"י ייבוא השם בראש הקובץ )מעל הגדרת המחלקה( import java.util.arrays;... System.out.println("Before: x=" + Arrays.toString(arr)); 30

31 משפט import כאשר עושים שימוש נרחב במחלקות מחבילה מסויימת לייבא את שמות כל המחלקות במשפט import יחיד: ניתן import java.util.*;... System.out.println("Before: x=" + Arrays.toString(arr)); השימוש ב-* אינו רקורסיבי, כלומר יש צורך במשפט import נפרד עבור כל תת חבילה: // for classes directly under subpackage import package.subpackage.*; // for classes directly under subsubpackage1 import package.subpackage.subsubpackage1.*; // only for the class SomeClass import package.subpackage.subsubpackage2.someclass; 31

32 משפט static import החל מ Java5 ניתן לייבא למרחב השמות את השרות או המשתנה הסטטי import( )static ובכך להימנע מציון שם המחלקה בגוף הקוד: package il.ac.tau.cs.software1.examples; import static il.ac.tau.cs.software1.examples.someotherclass.somemethod; public class SomeClass { public static void main(string[] args) { somemethod(); * גם ב static import ניתן להשתמש ב- 32

33 הערות על מרחב השמות ב- Java שימוש במשפט import אינו שותל קוד במחלקה והוא נועד לצורכי נוחות בלבד אין צורך לייבא מחלקות מאותה חבילה אין צורך לייבא את החבילה java.lang ייבוא כוללני מדי של שמות מעיד על צימוד חזק בין מודולים ייבוא של חבילות עם מחלקות באותו שם יוצר ambiguity של הקומפיילר וגורר טעות קומפילציה )"התנגשות שמות"( סביבות הפיתוח המודרניות יודעות לארגן בצורה אוטומטית את משפטי ה import כדי להימנע מייבוא גורף מדי pollution"( )"name 33

34 CLASSPATH איפה נמצאות המחלקות? איך יודעים הקומפיילר וה- JVM היכן לחפש את המחלקות המופיעות בקוד המקור או ה?byte code קיים משתנה סביבה בשם CLASSPATH המכיל שמות של תיקיות במערכת הקבצים שם יש לחפש מחלקות הנזכרות בתוכנית ה- CLASSPATH מכיל את תיקיות ה"שורש" של חבילות המחלקות ניתן להגדיר את המשתנה בכמה דרכים: הגדרת המשתנה בסביבה )תלוי במערכת ההפעלה( הגדרה אד-הוק ע"י הוספת תיקיות חיפוש בשורת הפקודה הדגל cp או )classpath הגדרת תיקיות החיפוש בסביבת הפיתוח )בעזרת 34

35 jar כאשר ספקי תוכנה נותנים ללקוחותיהם מספר גדול של מחלקות הם יכולים לארוז אותן כארכיב התוכנית )Java ARchive( jar אורזת מספר מחלקות לקובץ אחד תוך שמירה על מבנה החבילות הפנימי שלהן הפורמט תואם למקובל בתוכנות דומות כגון zip, tar, rar ואחרות כדי להשתמש במחלקות הארוזות אין צורך לפרוס את קובץ ה- jar ניתן להוסיפו ל CLASSPATH של התוכנית התוכנית jar היא חלק מה- JDK מתוך סביבת הפיתוח וניתן להשתמש בה משורת הפקודה או 35

36 API and Javadoc קובץ ה- jar עשוי שלא להכיל קובצי מקור כלל, אלא רק קובצי class )למשל משיקולי זכויות יוצרים( איך יכיר לקוח שקיבל jar מספק תוכנה כלשהו את הפונקציות והמשתנים הנמצאים בתוך ה-,jar כדי שיוכל לעבוד איתם? בעולם התוכנה מקובל לספק ביחד עם הספריות גם מסמך תיעוד, המפרט את שמות וחתימות המחלקות, השרותים והמשתנים יחד עם תיאור מילולי של אופן השימוש בהם תוכנה בשם javadoc מחוללת תיעוד אוטומטי html הערות התיעוד שהופיעו בגוף קובצי המקור בפורמט על בסיס )Application Programming Interface( תיעוד זה מכונה API תוכנת ה javadoc היא חלק מה- JDK הפקודה או מתוך סביבת הפיתוח וניתן להשתמש בה משורת 36

37 Javadoc /** Documentation for the package */ package somepackage; /** Documentation for the class your name here */ public class SomeClass { /** Documentation for the class variable */ public static int somevariable; /** Documentation for the class method x documentation for parameter x y documentation for parameter y * documentation for return value */ public static int somemethod(int x, int y, int z){ // this comment would NOT be included in the documentation return 0; 37

38 Javadoc כך זה ניראה ב :eclipse חלק מדף ה html שנוצר 38

39 Java API ניתן למצוא את התיעוד של כל ספריות ה Java באמצעות javadoc באתר של חברת.Oracle 39

40 תיעוד וקוד בעזרת מחולל קוד אוטומטי הופך התיעוד לחלק בלתי נפרד מקוד התוכנית הדבר משפר את הסיכוי ששינויים עתידיים בקוד יופיעו מיידית גם בתיעוד וכך תשמר העקביות בין השניים 40

41 מחלקות כטיפוסי נתונים תוכנה 1 בשפת 41 Java

42 מחלקות כטיפוסי נתונים ביסודה של גישת התכנות מונחה העצמים קיימת ההנחה שניתן לייצג ישויות מעולם הבעיה ע"י ישויות בשפת התכנות בכתיבת מערכת תוכנה בתחום מסוים,)domain( נרצה לתאר את המרכיבים השונים באותו תחום כטיפוסים ומשתנים בתוכנית המחשב התחומים שבהם נכתבות מערכות תוכנה מגוונים: בנקאות, ספורט, תרופות, מוצרי צריכה, משחקים ומולטימדיה, פיסיקה ומדע, מנהלה, מסחר ושרותים... יש צורך בהגדרת טיפוסי נתונים שישקפו את התחום, כדי שנוכל לעלות ברמת ההפשטה שבה אנו כותבים תוכניות 42

43 מחלקות כטיפוסי נתונים מחלקות מגדירות טיפוסים שהם הרכבה של טיפוסים אחרים )יסודיים או מחלקות בעצמם( )object( מופע )instance( של מחלקה נקרא עצם בשפת Java הגישה לעצמים היא באמצעות טיפוסי הפניה לעצם לא ניתן לגשת לעצם עצמו. כל מופע עשוי להכיל: נתונים fields( )data members, instance שרותים methods( )instance פונקציות אתחול )בנאים, )constructors 43

44 מחלקות ועצמים כבר ראינו בקורס שימוש בטיפוסים שאינם פרימיטיביים: מחרוזת ומערך גם ראינו שעקב שכיחות השימוש בהם יש להם הקלות תחביריות מסוימות )פטור מ- new והעמסת אופרטור +( ראינו כי עבודה עם טיפוסים אלה מערבת שתי ישויות נפרדות: העצם: המכיל את המידע ההפנייה: משתנה שדרכו ניתן לגשת לעצם זאת בשונה ממשתנים יסודיים )טיפוסים פרימיטיביים( int i =5, j = 7; String s = "Hello", t = "World"; דוגמא: ו- "world" הם מופעים של "hello" כשם ש int הם מופעים של j ו- i s.string ו t הם הפניות למחרוזות. 44

45 שרותי מופע למחלקות יש שרותי מופע פונקציות אשר מופעלות על מופע מסוים של המחלקה תחביר של הפעלת שרות מופע הוא: לדוגמא: זאת בשונה מזימון שרות מחלקה לדוגמא: objref.methodname(arguments) String str = "SupercaliFrajalistic"; int len = str.length(); :)static( ClassName.methodName(arguments) String.valueOf(15); // returns the string 15 שימו של כי האופרטור נקודה ).( משמש בשני המקרים בתפקידים שונים לגמרי! 45

46 שימוש במחלקות קיימות לטיפוס מחלקה תכונות בסיסיות, אשר סיפק כותב המחלקה, ואולם ניתן לבצע עם העצמים פעולות מורכבות יותר ע"י שימוש באותן תכונות את התכונות הבסיסיות יכול הספק לציין למשל בקובץ תיעוד תיעוד נכון יתאר מה השרותים הללו עושים ולא איך הם ממומשים התיעוד יפרט את חתימת השרותים ואת החוזה שלהם נתבונן במחלקה Turtle המייצגת צב לוגו המתקדם על משטח ציור כאשר זנבו למטה הוא מצייר קו במסלול ההתקדמות כאשר זנבו למעלה הוא מתקדם ללא ציור כותב המחלקה לא סיפק את הקוד שלה אלא רק עמוד תיעוד המתאר את הצב )המחלקה ארוזה ב JAR של קובצי )class 46

47 Turtle API בנאי פונקצית אתחול - ניתן לייצר מופעים חדשים של המחלקה ע"י קריאה לבנאי עם האופרטור new נפריד בין 2 שרותים סוגים שונים: שרותי מחלקה אינם מתייחסים לעצם מסוים, מסומנים static שרותי מופע שרותים אשר מתייחסים לעצם מסוים. יופנו לעצם מסוים ע"י שימוש באופרטור הנקודה

48 Turtle API סוגים של שרותי מופע:.1 שאילתות )queries( שרותים שיש להם ערך מוחזר בדרך כלל לא משנים את מצב העצם בשיעור הבא נדון בסוגים שונים של שאילתות פקודות )commands(.2 שרותים ללא ערך מוחזר בדרך כלל משנים את מצב העצם שעליו הם פועלים 48

49 דוגמת שימוש public class TurleClient { public static void main(string[] args) { Turtle leonardo = new Turtle(); if(!leonardo.istaildown()) leonardo.taildown(); leonardo.moveforward(50); leonardo.turnright(90); leonardo.moveforward(50); leonardo.turnright(90); leonardo.moveforward(50); leonardo.turnright(90); leonardo.moveforward(50); leonardo.turnright(90); 49

50 עוד דוגמת שימוש public class TurleClient { public static void main(string[] args) { Turtle leonardo = new Turtle(); leonardo.taildown(); drawsquarepattern(leonardo, 50, 10); public static void drawsquare(turtle t, int size) { for (int i = 0; i < 4; i++) { t.moveforward(size); t.turnright(90); public static void drawsquarepattern(turtle t, int size, int angle) { for (int i = 0; i < 360/angle; i++) { drawsquare(t, size); t.turnright(angle); 50

51 האם המחלקה צריכה להכיל כל שירות אפשרי? מדוע המחלקה Turtle לא הכילה מלכתחילה את השרותים? drawsquarepattern ו- drawsquare יש לכך יתרונות וחסרונות איך לימדנו את הצב את התעלולים החדשים? נשים לב להבדל בין השירותים הסטטיים שמקבלים עצם כארגומנט ומבצעים עליו פעולות ובין שרותי המופע אשר אינם מקבלים את העצם כארגומנט מפורש )העצם מועבר מאחורי הקלעים( 51

52 הגדרת טיפוסים חדשים תוכנה 1 בשפת 52 Java

53 The cookie cutter כאשר מכינים עוגיות מקובל להשתמש בתבנית ברזל או פלסטיק כדי ליצור עוגיות בצורות מעניינות )כוכבים( תבנית העוגיות cutter( )cookie היא מעין מחלקה ליצירת עוגיות העוגיות עצמן הן מופעים )עצמים( שנוצקו מאותה תבנית כאשר ה JVM טוען לזכרון את קוד המחלקה עוד לא נוצר אף מופע של אותה המחלקה. המופעים יווצרו בזמן מאוחר יותר כאשר הלקוח של המחלקה יקרא מפורשות לאופרטור new אם יש לנו תבנית לעוגיות, זה לא אומר שיש לנו עוגיות. התבנית מגדירה את הצורה של העוגיות, אבל לא את הטעם שלהן )וניל? שוקולד?( 53

54 דוגמא נתבונן במחלקה MyDate לייצוג תאריכים: public class MyDate { int day; int month; int year; שימו לב! המשתנים month,day ו- year הוגדרו ללא המציין static ולכן בכל מופע עתידי של עצם מהמחלקה MyDate יופיעו השדות האלה שאלה: כאשר ה JVM טוען לזיכרון את המחלקה איפה בזיכרון נמצאים השדות month,day ו-?year תשובה: הם עוד לא נמצאים! הם יווצרו רק כאשר לקוח ייצר מופע )עצם, אובייקט( מהמחלקה 54

55 לקוח של המחלקה MyDate לקוח של המחלקה הוא קטע קוד המשתמש ב- MyDate למשל: כנראה שמי שכותב יישום של יומן פגישות צריך להשתמש במחלקה דוגמא: public class MyDateClient { public static void main(string[] args) { MyDate d1 = new MyDate(); d1.day = 29; d1.month = 2; d1.year = 1984; System.out.println(d1.day + "/" + d1.month + "/" + d1.year); בדוגמא אנו רואים: שימוש באופרטור ה new ליצירת מופע חדש מטיפוס MyDate שימוש באופרטור הנקודה לגישה לשדה של המופע המוצבע ע"י d1 55

56 אם שרות, אז עד הסוף האם התאריך d1 מייצג תאריך תקין? מה יעשה כותב היומן כאשר יצטרך להזיז את הפגישה בשבוע? האם += 7 d1.day? כמו כן, אם למחלקה כמה לקוחות שונים אצל כל אחד מהלקוחות אזי הלוגיקה הזו תהיה משוכפלת אחריותו של מי לוודא את תקינות התאריכים ולממש את הלוגיקה הנלווית? המחלקה היא גם מודול. אחריותו של הספק כותב המחלקה לממש את כל הלוגיקה הנלווית לייצוג תאריכים כדי לאכוף את עקביות המימוש )משתמר המחלקה( על משתני המופע להיות פרטיים 56

57 public class MyDate { private int day; private int month; private int year; public static void incrementdate(mydate d){ // changes d to be the consequent day בהמשך ניראה מימוש אחר של השירותים של.MyData במימוש זה, לא נצטרך לשלוח את d כפרמטר לשירותים. public static String tostring(mydate d){ return d.day + "/" + d.month + "/" + d.year; public static void setday(mydate d, int day){ /* changes the day part of d to be day if * the resulting date is legal */ public static int getday(mydate d){ return d.day; private static boolean islegal(mydate d){ // returns if d represents a legal date // more... תוכנה 1 בשפת Java 57

58 נראות פרטית מכיוון שהשדות day,month ו- year הוגדרו בנראות פרטית )private( לא ניתן להשתמש בהם מחוץ למחלקה )שגיאת קומפילציה( public class MyDateClient { public static void main(string[] args) { MyDate d1 = new MyDate(); d1.day = 29; d1.month = 2; d1.year = 1984; כדי לשנות את ערכם יש להשתמש בשרותים הציבוריים שהוגדרו לשם כך 58

59 לקוח של המחלקה MyDate public class MyDateClient { public static void main(string[] args) { MyDate d1 = new MyDate(); MyDate.setDay(d1, 29); MyDate.setMonth(d1, 2); MyDate.setYear(d1, 1984); System.out.println(MyDate.toString(d1)); כעת הדוגמא מתקמפלת אך עדיין נותרו בה שתי בעיות: השימוש בפונקציות גלובליות )סטטיות( מסורבל עבור כל פונקציה אנו צריכים להעביר את d1 כארגומנט מיד לאחר השימוש באופרטור ה new קיבלנו עצם במצב לא עיקבי עד לביצוע השמת התאריכים הוא מייצג את התאריך הלא חוקי 0/0/00 59

60 שרותי מופע כדי לפתור את הבעיה הראשונה, נשתמש בסוג שני של שרותים הקיים ב Java שרותי מופע שירותי מופע הם שרותים המשויכים למופע מסוים הפעלה שלהם נחשבת כבקשה או שאלה מעצם מסוים והיא מתבצעת בעזרת אופרטור הנקודה בגלל שהבקשה היא מעצם מסוים, כארגומנט לפונקציה אין צורך להעביר אותו מאחורי הקלעים הקומפיילר מייצר משתנה בשם this ומעביר אותו לפונקציה, ממש כאילו העביר אותו המשתמש בעצמו 60

61 ממתקים להמונים ניתן לראות בשרותי מופע סוכר תחבירי sugar( )syntactic לשרותי מחלקה ניתן לדמיין את שרות המופע ()m של מחלקה C כאילו היה שרות מחלקה )סטטי( המקבל עצם מהטיפוס C כארגומנט: public class C { public void m(args){... public static void m(c thisobj, args) { 61

62 ממתקים להמונים בראייה זו, הקריאות למתודה ()m של לקוחות המחלקה C יתורגמו ע"י העברת ההפניה שעליה בוצעה הקריאה כארגומנט לשרות הסטטי: public class SomeClient { public static void main(string[] args) { C obj = new C(); obj.m(args); C.m(obj,args) 62

63 "לא מה שחשבת" שרותי מופע מספקים תכונה נוספת ל Java התחבירי פרט לסוכר בהמשך הקורס נראה כי לשרותי המופע ב Java תפקיד מרכזי בשיגור שרותים דינאמי dispatch(,)dynamic תכונה בשפה המאפשרת החלפת המימוש בזמן ריצה ופולימורפיזם תאור שרותי מופע כסוכר תחבירי הוא פשטני )ושגוי!( אך נותן אינטואיציה טובה לגבי פעולת השרות בשלב זה של הקורס 63

64 public class MyDate { private int day; private int month; private int year; הקוד הזה חוקי! המשתנה this מוכר בתוך שרותי המופע כאילו הועבר ע"י המשתמש. public static void incrementdate(mydate d){ // changes itself to be the consequent day אולם לא חובה להשתמש בו public static String tostring(mydate d){ return this. d.day + "/" + this. d.month + "/" + this. d.year; public static void setday(mydate d, int day){ /* changes the day part of itself to be day if * the resulting date is legal */ public static int getday(mydate d){ return this. d.day; private static boolean islegal(mydate d){ // returns if the argument represents a legal date // more... 64

65 public class MyDate { private int day; private int month; private int year; public void incrementdate(){ // changes current object to be the consequent day public String tostring(){ return day + "/" + month + "/" + year; public void setday(int day){ /* changes the day part of the current object to be day if * the resulting date is legal */ public int getday(){ return day; private boolean islegal(){ // returns if the current object represents a legal date // more... 65

66 בנאים )constructors( כדי לפתור את הבעיה שהעצם אינו מכיל ערך תקין מיד עם יצירתו נגדיר עבור המחלקה בנאי בנאי הוא פונקצית אתחול הנקראת ע"י אופרטור ה new מיד אחרי שהוקצה מקום לעצם החדש. שמה כשם המחלקה שהיא מאתחלת וחתימתה אינה כוללת ערך מוחזר המוטיבציה המרכזית להגדרת בנאים היא יצירת עצם שהוא עקבי עם השימוש המיועד שלו )בהמשך נדבר על משתמר מחלקה ומצב מופשט בעל משמעות( למשל, נרצה שהאובייקט ה MyDate שאנחנו מייצרים יכיל תאריך חוקי מיד עם יצירתו 66

67 public class MyDate { public MyDate(int day, int month, int year) { this.day = day; this.month = month; this.year = year; הגדרת בנאי ל MyDate //... public class MyDateClient { קוד לקוח המשתמש ב- MyDate public static void main(string[] args) { MyDate d1 = new MyDate(29,2,1984); d1.incrementdate(); System.out.println(d1.toString()); 67

68 בנאים האם ניתן לוותר על השימוש ב this בבנאי שהגדרנו? public class MyDate { public MyDate(int day, int month, int year) { this.day = day; this.month = month; this.year = year; כעת מופיעה בקוד ההשמה הבאה: day=day; בגלל ששם השדה זהה לשם הפרמטר, הורדת השימוש ב this מייצרת השמה חסרת משמעות אשר אינה מאתחלת את השדה.day

69 בנאי ברירת מחדל במידה ולא הוגדר אף בנאי למחלקה, נוצר בנאי ברירת מחדל.)default constructor( בנאי ברירת המחדל מתנהג בדיוק כמו הבנאי הבא: public class MyDate { public MyDate() { ומאפשר יצירה של אובייקט מטיפוס MyDate באופן הבא: public static void main(string[] args) { MyDate d1 = new MyDate();

70 בנאים לאילו ערכים מאותחלים שדות מחלקה שלא אותחלו בבנאי? שדות של מחלקות מאותחלים אוטומטית לערכים הדיפולטיים של כל טיפוס false(,0(, null, כך שאין חובה לאתחל ערכים אלה בבנאי. זכרון שמוקצה על ה Heap מאותחל אוטומטית.

71 בנאים האם הקוד הבא יתקמפל? public class MyDate { public MyDate(int day, int month, int year) { this.day = day; this.month = month; this.year = year; public static void main(string[] args) { MyDate d1 = new MyDate(); בנאי ברירת מחדל נוצר רק כאשר לא הוגדר אף בנאי אחר במחלקה. אם קיים מימוש של בנאי כלשהו, הבנאי הריק לא נוצר אוטומטית ויש לממש אותו בקוד במידה ונרצה להשתמש בו.

72 מודל הזיכרון של זימון שרותי מופע

73 מודל הזיכרון של זימון שרותי מופע בדוגמא הבאה נראה כיצד מייצר הקומפיילר עבורנו את ההפניה this עבור כל בנאי וכל שרות מופע נתבונן במחלקה Point המייצגת נקודה במישור הדו מימדי. כמו כן המחלקה מנהלת מעקב בעזרת משתנה גלובלי )סטטי( אחר מספר העצמים שנוצרו מהמחלקה בהמשך הקורס נציג מימוש מלא ומעניין יותר של המחלקה, אולם כעת לצורך פשטות הדוגמא נסתפק בבנאי, שדה מחלקה, שני שדות מופע ושלושה שרותי מופע 73

74 public class Point { private static double numofpoints; private double x; private double y; public Point(double x, double y){ this.x = x; this.y = y; numofpoints++; public double getx() { return x; public void setx(double newx) { if(newx > 0.0 && newx < 100.0) dosetx(newx); public void dosetx(double newx) { x = newx; // More methods... 74

75 PointUser public class PointUser { public static void main(string[] args) { Point p1 = new Point(1.0, 2.0); Point p2 = new Point(10.0, 20.0); p1.setx(11.0); p2.setx(21.0); System.out.println("p1.x == " + p1.getx()); 75

76 Point(x,y) this y 2.0 בכל הפעלה של במהלך שרות ריצת מופע או בנאי,בנאי יש ההפניהעצם this מטרה מצביעה שעליו העצם הופעלשזה השרות. עתהההפניה הוקצה this מצביעה )target( לעצם זה STACK HEAP Point.numOfPoints 10 x 1.0 main p1 args [ ] x y public class PointUser { public static void main(string[] args) { Point p1 = new Point(1.0, 2.0); Point p2 = new Point(10.0, 20.0); p1.setx(11.0); p2.setx(21.0); public class Point { CODE public Point(double x, double y){ this.x = x; this.y = y; numofpoints++; public double getx() { return x; System.out.println("p1.x == " + p1.getx()); public void setx(double newx) { if(newx > 0.0 && newx < 100.0) dosetx(newx); public void dosetx(double newx) { x = newx; 76

77 Point(x,y) this y 20.0 STACK HEAP Point.numOfPoints main x 10.0 p2 x y p1 args [ ] x y public class PointUser { public static void main(string[] args) { Point p1 = new Point(1.0, 2.0); Point p2 = new Point(10.0, 20.0); p1.setx(11.0); p2.setx(21.0); public class Point { CODE public Point(double x, double y){ this.x = x; this.y = y; numofpoints++; public double getx() { return x; System.out.println("p1.x == " + p1.getx()); public void setx(double newx) { if(newx > 0.0 && newx < 100.0) dosetx(newx); public void dosetx(double newx) { x = newx; 77

78 dosetx this newx 11.0 this.x הוא העצם = newx עצם הקריאה היא בעצם? המטרה בעצם dosetx(newx) איזה בזימון הקריאה ההשמה עצם שלהוא שרות= x מטרת מופע היא this.dosetx(newx) ההפניה this תצביע לעצם זה שעליו הופעל השרות. setx this STACK HEAP Point.numOfPoints main newx 11.0 p2 x y p1 args [ ] x y public class PointUser { public static void main(string[] args) { Point p1 = new Point(1.0, 2.0); Point p2 = new Point(10.0, 20.0); p1.setx(11.0); p2.setx(21.0); public class Point { CODE public Point(double x, double y){ this.x = x; this.y = y; numofpoints++; public double getx() { return x; System.out.println("p1.x == " + p1.getx()); public void setx(double newx) { if(newx > 0.0 && newx < 100.0) dosetx(newx); this.dosetx(newx); 78 public void dosetx(double newx) { this.x x = newx; = newx;

79 dosetx this newx 21.0 this.x = newx עצם הקריאה היא סוכר? המטרה סוכר תחבירי הואשל תחבירי העצם dosetx(newx) שרות= x מטרת מופעהיא איזה בזימון הקריאה ההשמהשל עצם הוא ( this.dosetx(newxתצביע לעצם זה שעליו של הופעל השרות. ההפניה setx this STACK HEAP Point.numOfPoints main newx 21.0 p2 x y p1 args [ ] x y public class PointUser { public static void main(string[] args) { Point p1 = new Point(1.0, 2.0); Point p2 = new Point(10.0, 20.0); p1.setx(11.0); p2.setx(21.0); public class Point { CODE public Point(double x, double y){ this.x = x; this.y = y; numofpoints++; public double getx() { return x; System.out.println("p1.x == " + p1.getx()); public void setx(double newx) { if(newx > 0.0 && newx < 100.0) dosetx(newx); this.dosetx(newx); 79 public void dosetx(double newx) { this.x x = newx; = newx;

80 איזה המשפט עצם "x הוא מטרת "return הוא הקריאה? בעצם this.x" "return getx main this p2 STACK HEAP x 21.0 y 20.0 Point.numOfPoints 2 11 p1 args [ ] x y p1.x == p1.x == 11 public class PointUser { public static void main(string[] args) { Point p1 = new Point(1.0, 2.0); Point p2 = new Point(10.0, 20.0); p1.setx(11.0); p2.setx(21.0); public class Point { CODE public Point(double x, double y){ this.x = x; this.y = y; numofpoints++; public double getx() { return this.x; System.out.println("p1.x == " + p1.getx()); public void setx(double newx) { if(newx > 0.0 && newx < 100.0) dosetx(newx); 80 public void dosetx(double newx) { this.x x = newx; = newx;

81 סיכום ביניים שרותי מופע methods( )instance בשונה משרותי מחלקה )this( פועלים על עצם מסוים )static method( בעוד ששרותי מחלקה פועלים בדרך כלל על הארגומנטים שלהם משתני מופע fields( )instance בשונה ממשתני מחלקה fields( )static הם שדות בתוך עצמים. הם נוצרים רק כאשר נוצר עצם חדש מהמחלקה )ע"י )new בעוד ששדות מחלקה הם משתנים גלובלים. קיים עותק אחד שלהם, שנוצר בעת טעינת קוד המחלקה לזכרון, ללא קשר ליצירת עצמים מאותה המחלקה 81